home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / PROGRAM / CTOOLS10.ARJ / RANDOM.C < prev    next >
C/C++ Source or Header  |  1991-12-31  |  5KB  |  179 lines
  1. /****************************************************************************
  2. *
  3. *                    Copyright (C) 1991 Kendall Bennett.
  4. *                            All rights reserved.
  5. *
  6. * Filename:        $RCSfile: random.c $
  7. * Version:        $Revision: 1.3 $
  8. *
  9. * Language:        ANSI C
  10. * Environment:    any
  11. *
  12. * Description:    A module to produce random number in many different
  13. *                formats. The numbers are produces using the linear
  14. *                congruential method. The routines are all based on
  15. *                long integers (32 bits on an IBM PC), so the
  16. *                computation is not as efficient as it could be for the
  17. *                IBM PC environment. We could recode it using 16 bit
  18. *                integers to speed it up, but at present that is
  19. *                unneeded.
  20. *
  21. * $Id: random.c 1.3 91/12/31 19:40:21 kjb Exp $
  22. *
  23. * Revision History:
  24. * -----------------
  25. *
  26. * $Log:    random.c $
  27. * Revision 1.3  91/12/31  19:40:21  kjb
  28. * Modified include file directories
  29. * 
  30. * Revision 1.2  91/09/03  18:28:22  ROOT_DOS
  31. * Ported to UNIX.
  32. * 
  33. * Revision 1.1  91/08/16  10:54:35  ROOT_DOS
  34. * Initial revision
  35. * 
  36. ****************************************************************************/
  37.  
  38. #include <stdio.h>
  39. #include <malloc.h>
  40. #include "random.h"
  41.  
  42. /*------------------------- Global variables ------------------------------*/
  43.  
  44. static long    seed;                    /* Seed for random number generator    */
  45.  
  46. /*-------------------------- Implementation -------------------------------*/
  47.  
  48. #define    M    100000000L                /* Special 'magic' values required    */
  49. #define    M1    10000L                    /* by the random number routines.    */
  50. #define    B    31415821L
  51.  
  52. void randinit(long s)
  53. /****************************************************************************
  54. *
  55. * Function:        randinit
  56. * Parameters:    long    seed    -    Number to seed generator with.
  57. * Returns:        Nothing.
  58. *
  59. * Description:    Seed the random number generator.
  60. *
  61. ****************************************************************************/
  62. {
  63.     seed = s;
  64. }
  65.  
  66. static long mult(long p,long q)
  67. /****************************************************************************
  68. *
  69. * Function:        mult
  70. * Parameters:    long    p    - First number to multiply
  71. *                long    q    - Second number to multiply
  72. * Returns:        Result of the multiplication.
  73. *
  74. * Description:    Multiplies two large numbers together by breaking it into
  75. *                pieces, and ignoring any overflow produced.
  76. *
  77. ****************************************************************************/
  78. {
  79.     long    p1,p0,q1,q0;
  80.  
  81.     p1 = p / M1;    p0 = p % M1;
  82.     q1 = q / M1;    q0 = q % M1;
  83.     return (((p0 * q1 + p1 * q0) % M1) * M1 + p0 * q0) % M;
  84. }
  85.  
  86. long randomlong(long range)
  87. /****************************************************************************
  88. *
  89. * Function:        randomlong
  90. * Parameters:    None.
  91. * Returns:        A psuedo-random number in the range 0-'range'.
  92. *
  93. * Description:    random generates a psuedo-random number between 0 and
  94. *                'range'.
  95. *
  96. ****************************************************************************/
  97. {
  98.     seed = (mult(seed,B) + 1) % M;
  99.     return ((seed/M1) * range) / M1;
  100. }
  101.  
  102. double randomfloat(void)
  103. /****************************************************************************
  104. *
  105. * Function:        randomfloat
  106. * Parameters:    None.
  107. * Returns:        A psuedo-random number in the range 0-1.
  108. *
  109. * Description:    randomfloat generates a psuedo-random number between
  110. *                0 and 1.
  111. *
  112. ****************************************************************************/
  113. {
  114.     seed = (mult(seed,B) + 1) % M;
  115.     return (double)seed/(double)M;
  116. }
  117.  
  118. double chisquare(int N,int r,long s)
  119. /****************************************************************************
  120. *
  121. * Function:        chisquare
  122. * Parameters:    int        N    - Number of iterations to complete (at least
  123. *                              10*r)
  124. *                int        r    - Range of numbers to test
  125. *                long    s    - The seed value for the test.
  126. * Returns:        A floating point number equal to the chisquared value.
  127. *
  128. * Description:    Computes the chisquared value for the floating point number
  129. *                generator in this package for debugging purposes. This
  130. *                value should be within 20% of the value specified for r,
  131. *                and the test should be completed at least 10 times, since
  132. *                the computation could be wrong 1 out of 10 times.
  133. *
  134. ****************************************************************************/
  135. {
  136.     int        i;
  137.     long    t;
  138.     long    *f;
  139.  
  140.     if ((f = (long *)malloc(sizeof(long) * r)) == NULL) {
  141.         fprintf(stderr,"Not enough memory: chisquare\n");
  142.         exit(1);
  143.         }
  144.     randinit(s);
  145.     for (i = 0; i < r; i++)
  146.         f[i] = 0;
  147.     for (i = 0; i < N; i++)
  148.         f[(int)randomlong(r)]++;
  149.     for (i = 0, t = 0; i < r; i++)
  150.         t += f[i]*f[i];
  151.     free(f);
  152.     return ((r * (double)t/N) - N);
  153. }
  154.  
  155. #ifdef    TESTING
  156.  
  157. void main(void)
  158. {
  159.     int        r,i,percent,final;
  160.     float    chi;
  161.  
  162.     r = 100;
  163.     final = 0;
  164.     for (i = 0; i < 10; i++) {
  165.         chi = chisquare(10*r,r,time(NULL));
  166.         percent = abs(100 - (int)(chi * 100 / r));
  167.         printf("%-2d - Range: %4d -> Chisquare: %f (%d%%)\n",i+1,r,chi,percent);
  168.         r += 100;
  169.         final += percent;
  170.         }
  171.     final /= (i + 1);            /* Determine average percentage            */
  172.     if (final < 20)
  173.         printf("\nRandom number routine is good (averaged %d%% proximity to 'range')\n",final);
  174.     else
  175.         printf("\nRandom number routine is bad (averaged %d%% proximity to 'range')\n",final);
  176. }
  177.  
  178. #endif
  179.